This is much more elegant than monkey-patching... but I'm not sure it solves the 1.0 problem.

The core problem in 1.0 is that the addBidResponse function is no longer global. Instead, each auction instance makes its own addBidResponse.

This means that the currency module (which is global) can't get a reference to it, so it would be impossible to call addHook using the method reference directly.

I think the global API (hooks[name].addHook() and hooks[name].createHook()) has a similar, related problem.

The first auction runs createHook, which makes a hooks['addBidResponse']. The currency module adds its decorator. Then a second auction gets created, which sets hooks['addBidResponse'] to a new object. The currency module would only get applied once.

I haven't looked into the 1.0 branch closely enough yet... but I think there's also a race condition here. If a pub does something like:

pbjs.setConfig(currencyStuff);
setTimeout(function() {
  pbjs.callBids();
}, 5000)

then there's a good chance that initCurrency will run before createHook ever gets created. In that case, hooks['addBidResponse'].addHook() will end in an undefined reference error.

So I attempted a few methods to solve the auction instance problems w/ 1.0 such as allowing callbacks to hooks and having addBidResponse be one, that way it can keep its closure context and we could have a global hook.

However, the method that I think makes the most sense is fixing addBidResponse. In its current state it requires a lot of context to operate, and that context is grabbed from its outside scope creating a closure with a bunch of implicit dependencies. It's very hard to debug and follow. I suggest we make instance dependencies explicit through use of this, such as this._bidderRequest.find as opposed to _bidderRequest.find. This allows us to set the appropriate instance context for each callback passed to the adapters. This would also allow us to move addBidResponse to a more global scope to create a hook.

I updated this pull-request to be more accepting of context passing and binding for hook functions.

The changes to auction.js would look similar to this:

// outer module scope
export const addBidResponse = createHook('asyncSeries', function addBidResponse(adUnitCode, bid) {
  ...
  function addBidToAuction() {
    events.emit(CONSTANTS.EVENTS.BID_RESPONSE, bid);
    this.addBidReceived(bid); // instance functions and properties referenced by this
  }
})

// callBids auction instance method could go back to the following
function callBids() {
  ...

  adaptermanager.callBids(_adUnits, bidRequests, addBidResponse.bind(this), done.bind(this));
};

Basically we'll be treating addBidResponse more like a public prototype method (even though we don't use classes) than an inner private closure function, which I think is ideal. Thoughts?

updated